﻿using HomeWork;
using ParticeInClass;
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Xml.Linq;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace HomeWork
{
    public class Program
    {
        //static void Main(string[] args)
        //{
        //{
        //<-----面向对象2-面向对象4作业为倒序-------->，后面为顺序

        //1、写一段代码，能根据半径获取圆的周长（= 2倍半径乘以圆周率）和面积（= 半径的平方乘以圆周率）
        //声明一个变量radius，代表半径，给它赋一个任意值；
        //使用alert(/*这里放表达式*/)输出周长;
        //使用alert(/*这里放表达式*/)输出面积;

        //int radis = 10;
        //// 圆的周长和面积
        //Console.WriteLine("周长为" + radis * 2 * 3.14);
        //Console.WriteLine("面积为" + radis * radis * 3.14);

        //2、声明一个变量number，给number赋整数值，写出以下表达式，判断number是不是：
        //正数
        //大于100的正数
        //大于100小于1000的正数
        //10000以内能被3整除的奇数

        //int number = 102;
        //NumberJudgment(number);


        //3、声明变量sname（学生姓名），将你的名字（比如：阿泰）赋值给它；然后利用它输出入栈口号，比如：我是阿泰，学业不成，誓不出栈！
        //string sname = "江彦臻";
        //SnameStudy(sname);


        //面向对象3
        //1、声明变量age（年龄），写一段代码能根据age输出文本：成年（满18岁），或者未成年（未满18岁） 
        //年龄不应小于或等于0;
        //int age = -5;
        //AdultDivision(age);


        //2、写一段代码，能够根据score（成绩）输出文本：
        //60以下：不及格
        //80以上：优秀
        //60 - 80：及格

        //int score = 75;
        //ScoreGrading(score);


        //面向对象4
        //1、分别用for循环和while循环直接输出：1,2,3,4,5 和 1,3,5,7,9
        // for循环1-5
        //ForFive();

        //下一道题
        //ForFive();

        //while循环1-9
        //WhileNine();

        //下一道题
        //ForNine();


        //2、分别利用while和for循环，计算出1000 + 999 + 998 + 997 +……+100的值
        //int sum = 0;
        //SumThousandFor(sum);

        //下一道题while循环
        //int i = 1000,
        //    sum = 0;
        //SumThousandWhile(sum, i);



        //3、让电脑计算并输出：99 + 97 + 95 + 93 + ...+1的值
        //int i = 99,
        //sum = 0;
        //SumHundredOdd(sum, i);

        // 下一道题for循环
        //int sum = 0;
        //SumHundredOddFor(0);


        //5、声明一个数组ids，存放若干整数，利用：
        //    while
        //    for循环 i--
        //输出数组中每个元素的值
        //double[] ids = [59, 28, 155, 60, 194, 152, 51, 121, 171, 46];
        //int i = 0;
        //idsFor(ids);
        //idsWhile(ids, i);


        //6、声明一个数组odds，利用循环把100以内的不能被3整除的数按从小到大的顺序存入其中
        //double[] odds = new double[70];
        //IdsFor(odds);
        //输出数组中每个元素的值
        //for (int i = 0; i < odds.Length; i++)
        //{
        //    Console.WriteLine(odds[i]);
        //}


        //7、计算出odds数组中所有元素的和
        //double[] odds = new double[70];
        //SumOdds(odds);


        //8、同时 / 一次性找到并输出数组中的最大最小值
        //double[] odds = new double[70]; //数组
        //MaxMin(odds);


        //9、完成课堂中的等腰三角形输出；再利用循环，输出这么一个梯形：
        //TrapezoidalDigit();
        //IsoscelesTtriangle();


        //10、输出10000以内的所有“素数/质数”（只能被自己和1整除的数） 
        //double[] ids = new double[1250]; //创建一个数组存储质数
        //PrimeNumber(ids);

        //面向对象5
        //1、声明一个函数：函数名为add，接受两个参数a和b，调用该函数，能返回两个参数的和。
        //Console.WriteLine(Add(1, 2));


        //2、声明函数welcome(sname)，能弹出窗口，显示包含学生姓名（sname）的欢迎词，比如：“源栈欢迎你！阿泰”（sname = 阿泰）                        
        //3、将之前“找出素数”的代码封装成一个函数findPrime(max)，可以控制台输出max以内的所有素数。
        //string num = Console.ReadLine();
        //double max = Convert.ToDouble(num);
        //FindPrime(max);
        //for (int i = 0; i < FindPrime(max).Length; i++)
        //{
        //    Console.WriteLine(FindPrime(max)[i]);
        //}

        //4、声明以下函数，接受一个数组作为参数：
        //double[] ids = { 52, 75, 84, 91, 111, 564, 34, 46, 97 };
        //getSum：返回数组中所有元素的和
        //Console.WriteLine(GetSum(ids));

        //getAverage：返回数组中所有元素的平均值
        //Console.WriteLine(GetAverage(ids));

        //getMax：返回数组中最大的元素
        //Console.WriteLine(GetMax(ids));

        //getMin：返回数组中最小的元素
        //Console.WriteLine(GetMin(ids));

        //getRange：数组中最大一个元素和最小元素的差
        //Console.WriteLine(GetRange(ids));


        //5、设计一个函数sum，能（用遍历而不是公式）求出任意等差数列（如：1,3,5……或者0,5,10,15……）之和。
        //Console.WriteLine(Sum(0, 5, 5));

        //6、设计一个函数swap，能够交换数组中的任意两个元素（提示：引入中间变量）
        //double[] ids = { 1, 20, 3, 40, 5 };
        // double[] idsSwap = Swap(ids,30,40);
        // for (int i = 0; i < idsSwap.Length; i++)
        // {
        //     Console.WriteLine(ids[i]);
        // }


        //面向对象2静态实例
        //1、观察“一起帮”的：
        //  1、注册 / 登录功能，定义一个User类（以下所有类都按“一个类一个文件”的原则组织），包含字段：Name（用户名）、Password（密码）和 邀请人（InvitedBy），和方法：
        //      Register()：能输出当前用户的注册信息，比如：fg开始注册，密码：1234，邀请人：dk
        //      Login()：能输出当前用户的登录信息，比如：fg开始登录，输入密码：1234
        //  2、求助版块，定义一个类Problem，包含字段：标题（Title）、正文（Body）、悬赏（Reward）和作者（Author）
        //  3、帮帮币版块，定义一个类HelpMoney，表示一行帮帮币交易数据，包含你认为应该包含的字段和方法
        //  4、每发布一个求助，该求助作者的帮帮币应该根据其悬赏金额予以冻结，这个过程应该实现在哪个类的哪个方法里面？

        //2、学生每上一节课，老师获得1个积分，如何体现？
        //3、考虑求助（Problem）的以下方法，哪些适合实例，哪些适合静态，然后添加到类中：
        //  Publish()：发布一篇求助，并将其保存到数据库
        //  Load(int Id)：根据Id从数据库获取一条求助
        //  Delete(int Id)：根据Id删除某个求助


        //User jyz = new User();
        //User feiGe = new User();
        //feiGe.name = "飞哥";
        //jyz.name = "江彦臻";
        //jyz.password = "8901845";
        //jyz.invitedBy = feiGe;
        //jyz.Register(); //输出注册
        //jyz.Login();    //输出登录

        //实例求助对象
        // Problem object1 = new Problem();
        // object1.Reward = 10;
        // object1.Title = "C#  ";
        // object1.Author = jyz;
        // object1.Body = "C#是一种面向对象的编程语言  ";

        //object1.Publish(); //发布求助
        //Problem.Load(1);   //静态方法，加载求助
        //Problem.Delete(1); //静态方法，删除求助

        // HelpMoney jyzAccount = new HelpMoney();

        // object1.HelpMoney = jyzAccount;
        // jyzAccount.Remark = "类和对象（二）作业";
        // jyzAccount.Kind = "悬赏测试";
        // object1.Publish();       //发布求助
        //jyzAccount.TradRecord(); //输出帮帮币交易记录


        //Student jyz = new Student();
        //jyz.attend();     //学生上课


        //面向对象类成员：构造函数，属性
        //User jyz = new User();
        //1、user.Password在类的外部只能改不能读
        //jyz.SetPassword("q8901845");

        //2、如果user.Name为“admin”，输入时修改为“系统管理员” 
        //jyz.SetName("jinfeng");
        //jyz.SetName("admin");

        //3、problem.Reward不能为负数 
        //Problem obj1 = new Problem();
        //obj1.SetReward(10);
        //Console.WriteLine(obj1.GetReward());

        //面向对象：继承

        //1、观察一起帮的求助（Problem）、文章（Article）和意见建议（Suggest），根据他们的特点，抽象出一个父类：内容（Content）
        //    1、Content中有一个字段：kind，记录内容的种类（problem / article / suggest等），只能被子类使用
        //    2、Content中的createTime，不能被子类使用，但只读属性PublishTime使用它为外部提供内容的发布时间
        //    3、其他方法和属性请自行考虑，尽量贴近一起帮的功能实现。
        //2、再为之前所有类（含User、HelpMoney等）抽象一个基类：Entity，包含一个只读的Id属性。
        //3、实例化上述所有类，调用他们：
        //   1、继承自父类的属性和方法
        //   2、自己的属性和方法


        //Student student = new Student();
        //Console.WriteLine(student.getid());

        //HelpMoney helpMoney = new HelpMoney();
        //Console.WriteLine(helpMoney.getid());

        //Suggest suggest1 = new Suggest();
        //suggest1.Title="一起帮";
        //suggest1.State = 1;
        //suggest1.Comment="很好";
        //suggest1.Author = new User();


        //suggest1.SetKind(suggest1);
        //suggest1.ifKind();

        //Content article = new Article();
        //article.SetKind(article);
        //article.ifKind();

        //Content problem = new Problem();
        //problem.SetKind(problem);
        //problem.ifKind();


        //利用继承和多态，实现下列功能：

        //1、所有Content都可以发布（Publish()），但是：
        //如果发布Article，需要Article作者消耗一个帮帮币
        //如果发布Problem，需要消耗Problem作者其设置悬赏数量的帮帮币
        //如果发布Suggest，不需要消耗帮帮币


        //1、发布Article
        //初始化对象
        //User jyz = new User();
        //jyz.SetName("jyz");

        //HelpMoney helpMoney = new HelpMoney();//初始化帮帮币

        //Article article = new Article();    //初始化Article
        //article.HelpMoney = helpMoney;    //设置帮帮币
        //Content content1 = article;

        ////设立参数
        //helpMoney.Owner = jyz;
        //helpMoney.Content = content1;

        ////发布Article
        //content1.Publish();

        //2、发布problem
        //User jyz = new User();
        //jyz.SetName("jyz");

        //HelpMoney helpMoney = new HelpMoney();

        //Problem problem1 = new Problem();
        //problem1.Reward = 50; //设置悬赏金额
        //problem1.HelpMoney = helpMoney;//设置帮帮币

        ////帮帮币设置参数
        //helpMoney.Owner=jyz;
        //helpMoney.Content = problem1; //设立参数
        //Content content1 = problem1;

        ////发布problem
        //content1.Publish();

        //3、发布建议

        //Content content1 = new Suggest();
        //content1.Publish();

        //添加一个新类ContentService，其中有一个发布（Release()）方法，可以发布各种文章。方法体内按顺序：
        //控制台输出：准备发布……
        //如题1根据文章种类不同，消耗不同的帮帮币
        //控制台输出：保存文章到数据库。
        //1、发布Article
        //User jyz = new User();
        //jyz.SetName("jyz");

        //HelpMoney helpMoney = new HelpMoney();//初始化帮帮币

        //Article article = new Article();    //初始化Article
        //article.HelpMoney = helpMoney;    //设置帮帮币
        //ContentService contentService = new ContentService();

        ////设置参数
        //helpMoney.Owner = jyz;            

        //contentService.Release(article); //发布Article

        //2、发布problem
        //User jyz = new User();
        //jyz.SetName("jyz");

        //HelpMoney helpMoney = new HelpMoney();//初始化帮帮币

        ////problem参数
        //Problem problem1 = new Problem();
        //problem1.Reward = -50; //设置悬赏金额
        //problem1.HelpMoney = helpMoney;//设置帮帮币

        ////帮帮币设置参数
        //helpMoney.Owner = jyz;
        //helpMoney.Content = problem1;
        //ContentService contentService = new ContentService();

        ////发布problem
        //contentService.Release(problem1);

        //3、发布建议
        //User jyz = new User();
        //jyz.SetName("jyz");
        //ContentService contentService = new ContentService();
        //contentService.Release();


        //时间漫谈
        //1、“一起帮”为了反爬虫访问，限定了用户的查询次数，即：每5分钟内最多不能访问超过若干个页面。请设计一个函数hasExpired(last)，能够检查当前时间是否已超过上次记录时间（last）5分钟
        //DateTime lastUpdated = DateTime.Now; // 当前时间
        //Console.WriteLine(CheckTime.HasExpired(lastUpdated)); // 输出：False（未超过5分钟）

        //DateTime fiveMinutesAndOneSecondAgo = DateTime.Now.AddMinutes(-5).AddSeconds(-1);
        //Console.WriteLine(CheckTime.HasExpired(fiveMinutesAndOneSecondAgo)); // 输出：True（超过5分钟）

        //2、类似第1题，“一起帮”还会检查用户上次登录是否已过24小时，请设计一个函数 isNewLogin(last)完成检查。
        //DateTime lastUpate = DateTime.Now;//当前时间
        //Console.WriteLine(CheckTime.IsNewLogin(lastUpate));    // 输出：False（未超过24小时）

        //DateTime lastUpdate = DateTime.Now.AddHours(-24).AddMinutes(-1); //上次登录时间
        //Console.WriteLine(CheckTime.IsNewLogin(lastUpdate)); //// 输出：True（超过24小时）

        //3、生成一个函数toChinese()，可将传入的日期参数（如：new Date()）转换成中文日期格式（如：2019年10月4日 16点54分）
        //DateTime date = new DateTime(1993, 9, 3, 12, 15, 30);
        //Console.WriteLine(CheckTime.ToChinese(date));

        //源栈的学费是按周计费的，所以请实现这两个函数：
        //1、GetDate()，能计算一个日期若干（日 / 周 / 月）后的日期
        //DateTime currentTime = DateTime.Now; // 当前时间
        //Console.WriteLine(CheckTime.GetDate(currentTime, 5, "day")); // 5天后的日期
        //Console.WriteLine(CheckTime.GetDate(currentTime, 2, "week")); // 2周后的日期
        //Console.WriteLine(CheckTime.GetDate(currentTime, 1, "month")); // 1个月后的日期
        //Console.WriteLine(CheckTime.GetDate()); 

        //2、ShowWeeksIn()给定任意一个年份，就能按周排列显示每周的起始日期，例如：
        //第1周 2021年1月2日 - 2021年1月8日
        //第2周 2021年1月9日 - 2021年1月15日
        //……
        //……
        //第x周 2021年12月x日 - 2021年12月28日

        //CheckTime.ShowWeeksIn(2021); // 显示2021年的每周起始日期

        //1、改造冒泡排序：
        //1、让结果从大到小排序
        //插入冒泡排序
        //double[] array = [9, 2, 3, 5, 4, 7, 6, 8, 1, 0];
        //for (int i = 0; i < array.Length - 1; i++)
        //{
        //    if (array[i] < array[i + 1])
        //    {
        //        for (int j = i + 1; j > 0; j--)
        //        {
        //            if (array[j] > array[j - 1])
        //            {
        //                double temp = array[j];
        //                array[j] = array[j - 1];
        //                array[j - 1] = temp;
        //            }
        //            else
        //            {
        //                break;
        //            }
        //        }
        //    }
        //}

        //标准冒泡排序
        //double[] array = [9, 2, 3, 5, -4, 7, -6, -8, 1, 0];
        //double[] array = [5, 3, 8, 4, 6];
        //for (int i = 0; i < array.Length - 1; i++)
        //{
        //    for (int j = 0; j < array.Length - i - 1; j++)
        //    {
        //        if (array[j] < array[j + 1])
        //        {
        //            double temp = array[j];
        //            array[j] = array[j + 1];
        //            array[j + 1] = temp;
        //        }
        //    }
        //}

        //for (int i = 0; i < array.Length; i++)
        //{
        //    Console.Write(array[i] + " ");
        //}


        //2、将其封装成方法bubbleSort()，且该方法既能按元素本身大小比较，也能按元素的绝对值（即：数组中可能有负数）进行比较
        //BubbleSort(array,true);  //默认从小到大排序


        //3、可以指定数组中的某一个值为最大（就像斗地主有“癞子”一样）
        //

        //double[] array = [9, 2, 3, 5, -4, 7, -6, -8, 1, 0];
        ////double[] array = [9, 2, -4];
        //MaxSort(array, -4); //默认从小到大排序

        //for (int i = 0; i < array.Length; i++)
        //{
        //    Console.Write(array[i] + " ");
        //}

        //2、完成二分查找法，将其封装成函数 / 方法：BinarySeek()
        //int[] array = [3, 7, 8, 12, 23, 35, 46, 59, 70, 108];
        //BinarySeek(array, 72);


        //3、彻底完成快速排序，将其封装成函数 / 方法：quickSort()
        ////从小到大排序
        //int[] array = [18, 7, 5, 9, 12, 23, 16, 32, 1, 3];
        //int[] array = [5, 3, 8, 4, 6, 2];
        //int left = 0;
        //int right = array.Length - 1;
        //quickSort(array, left, right);



        //1、按TDD的要求实现一个模拟栈（MimicStack），内部利用整数数组，能够：
        //    实例化时确定栈的深度（depth）
        //    压入（Push）数据：一次压入一个整数，且能提示：“栈已满”
        //    弹出（Pop）数据：一次弹出一个整数，且能提示：“栈已空”
        //    暴露该栈已存放多少数据（Stored），还能再存放的多少条数据（Empty）

        //MimicStackTest test = new MimicStackTest();
        //test.PushTest();
        //test.push10Test();
        //test.push15Test();

        //test.popTest();
        //}

        //}

        //10、输出10000以内的所有“素数/质数”（只能被自己和1整除的数） 
       //public static void PrimeNumber(double[] ids)
       // {
       //     int num = 0; //当前存储位置
       //     for (int i = 2; i <= 10000; i++)
       //     {
       //         bool isPrime = true;
       //         //检查i是否质数
       //         for (int j = 2; j < i; j++)
       //         {
       //             if (i % j == 0)
       //             { ////如果发现整除，立即跳出循环
       //                 isPrime = false;
       //                 break;
       //             }//else nothing   
       //         }
       //         if (isPrime)
       //         {
       //             ids[num] = i; // 通过索引赋值到数组
       //             num++;         // 移动到下一个位置
       //         }
       //     }
       //     for (int i = 0; i < ids.Length; i++)
       //     {
       //         Console.WriteLine(ids[i]);//输出数组中每个元素的值
       //     }
       // }


        //9、完成课堂中的等腰三角形输出；再利用循环，输出这么一个梯形：
        //static void IsoscelesTtriangle()
        //{
        //    //i: 第i排;
        //    for (int i = 1; i <= 4; i++)
        //    {
        //        String stars = "";
        //        String space = "";

        //        //i:多少个空格
        //        for (int j = 0; j < 4 - i; j++)
        //        {
        //            space += " ";
        //        }

        //        //j: 多少个星
        //        for (int j = 0; j < 2 * i - 1; j++)
        //        {
        //            stars = stars + "*";
        //        }



        //        Console.WriteLine(space+stars);
        //    }
        //}

        //static void TrapezoidalDigit()
        //{
        //    //第i排
        //    for (int i = 1; i <= 4; i++)
        //    {
        //        string space = "";
        //        string num = "";

        //        //i:多少个空格
        //        for (int j = 0; j < 4 - i; j++)
        //        {
        //            space += " ";
        //        }

        //        int number = i + 2;//每行数字

        //        //j:多少个数字
        //        for (int k = 1; k <= i + 2; k++)
        //        {
        //            num += number;
        //        }
        //        Console.WriteLine(space + num);
        //    }
        //}


        //8、同时/一次性找到并输出数组中的最大最小值
        //static void MaxMin(double[] odds)
        //{
        //    int i = 0;//i:第几位数组元素
        //    double sum = 0;//odds数组所有元素之和

        //    //j:100以内的数
        //    for (int j = 1; j < 100; j++)
        //    {
        //        if (j % 3 != 0)
        //        {
        //            odds[i] = j;//将100以内不能被3整除的数存入数组
        //            i++;
        //        } //else nothing	
        //    }

        //    double max = odds[0]; //存放最大值
        //    double min = odds[1]; //存放最小值

        //    //找最大值
        //    for (int k = 0; k < odds.Length; k++)
        //    {
        //        if (max < odds[k])
        //        {
        //            max = odds[k];
        //        }//else nothing
        //    }

        //    //找最小值
        //    for (int l = 0; l < odds.Length; l++)
        //    {
        //        if (min > odds[l])
        //        {
        //            min = odds[l];
        //        }//else nothing
        //    }
        //    Console.WriteLine("最大值为" + max + "最小值为" + min);
        //}


        //7、计算出odds数组中所有元素的和
        //static void SumOdds(double[] odds)
        //{
        //    double sum = 0;
        //    int i = 0;  //i:第几位数组元素
        //    //j:100以内的数
        //    for (int j = 1; j < 100; j++)
        //    {
        //        if (j % 3 != 0)
        //        {
        //            odds[i] = j; //将100以内不能被3整除的数存入数组
        //            i++;
        //        } //else nothing	
        //    }


        //k:第几位数组元素
        //for (int k = 0; k < odds.Length; k++)
        //{
        //    sum += odds[k];//数组中所有元素求和
        //}
        //Console.WriteLine("100以内不能被3整除的数的和为"+sum);
        //}

        //6、声明一个数组odds，利用循环把100以内的不能被3整除的数按从小到大的顺序存入其中
        //static void IdsFor(double[] odds)
        //{
        //    int i = 0;  //i:第几位数组元素
        //    //j:100以内的数
        //    for (int j = 1; j < 100; j++)
        //    {
        //        if (j % 3 != 0)
        //        {
        //            odds[i] = j;
        //            i++;
        //        } //else nothing	
        //    }
        //}


        //5、声明一个数组ids，存放若干整数，利用：
        //while输出数组
        //static void idsWhile(double[] ids, int i)
        //{
        //    while (i < ids.Length)
        //    {
        //        Console.WriteLine(ids[i]);
        //        i++;
        //    }
        //}

        //for输出数组
        //static void idsFor(double[] ids)
        //{
        //    for (int i = ids.Length - 1; i >= 0; i--)
        //    {
        //        Console.WriteLine(ids[i]);
        //    }
        //}


        //3、让电脑计算并输出：99 + 97 + 95 + 93 + ...+1的值
        //static void SumHundredOdd(int sum,int i) {
        //    while (i > 0)
        //    {
        //        if (i % 2 != 0)
        //        {
        //            sum += i;
        //        } //else	nothing;
        //        i--;
        //    }
        //    Console.WriteLine(sum);
        //}

        // 下一道题for循环
        //static void SumHundredOddFor(int sum)
        //{
        //    for (int i = 99; i > 0; i--)
        //    {
        //        if (i % 2 != 0)
        //        {
        //            sum += i;
        //        } //else	nothing;
        //    }
        //    Console.WriteLine(sum);
        //}


        //2、分别利用while和for循环，计算出1000 + 999 + 998 + 997 +……+100的值
        //static void SumThousandWhile(int sum, int i)
        //{
        //    while (i >= 100)
        //    {
        //        sum += i;
        //        i--;
        //    }
        //    Console.WriteLine(sum);
        //}

        //for循环：i:1000到100 
        //static void SumThousandFor(int sum)
        //{
        //    for (int i = 1000; i >= 100; i--)
        //    {
        //        sum += i;
        //    }
        //    Console.WriteLine(sum);
        //}

        //面向对象4
        //1、分别用for循环和while循环直接输出：1,2,3,4,5 和 1,3,5,7,9
        // for循环1-5
        //static void ForFive()
        //    {
        //        for (int i = 1; i <= 5; i++)
        //        {
        //            Console.WriteLine(i);
        //        }
        //    }

        //    //下一道题1-9
        //    static void ForNine()
        //    {
        //        for (int i = 1; i <= 9; i++)
        //        {
        //            if (i % 2 != 0)
        //            {
        //                Console.WriteLine(i);
        //            } //else	nothing;
        //        }
        //    }

        //    //while循环
        //    static void WhileFive()
        //    {
        //        int i = 0;
        //        while (i < 5)
        //        {
        //            i++;
        //            Console.WriteLine(i);
        //        }
        //    }

        //    //下一道题
        //    static void WhileNine()
        //    {
        //        int i = 0;
        //        while (i < 9)
        //        {
        //            i++;
        //            if (i % 2 != 0)
        //            {
        //                Console.WriteLine(i);
        //            } //else	nothing;
        //        }
        //    }


        //2、写一段代码，能够根据score（成绩）输出文本：
        //int score = 75;
        //static void ScoreGrading(int score)
        //{
        //    //成绩不应小于0或大于100;
        //    if (score < 0 || score > 100)
        //    {
        //        Console.WriteLine("越界啦...");
        //    }
        //    else //成绩0-100的;
        //    {
        //        if (score < 60)
        //        {
        //            Console.WriteLine("不及格");
        //        }
        //        else if (score >= 60 && score <= 80)
        //        {
        //            Console.WriteLine("及格");
        //        }
        //        else if (score > 80)
        //        {
        //            Console.WriteLine("优秀");
        //        }
        //        else
        //        {
        //            Console.WriteLine("咋回事啊，score=" + score);
        //        }
        //    }
        //}


        //面向对象3
        //1、声明变量age（年龄），写一段代码能根据age输出文本：成年（满18岁），或者未成年（未满18岁） 

        //static void AdultDivision(int age)
        //{
        //    //如果小于0
        //    if (age <= 0)
        //    {
        //        Console.WriteLine("出错了,年龄=" + age);
        //    }
        //    else //如果大于0
        //    {
        //        if (age < 18) //如果小于18
        //        {
        //            Console.WriteLine("未成年");
        //        }
        //        else //如果大于等于18
        //        {
        //            Console.WriteLine("成年");
        //        }
        //    }
        //}


        //面向对象2
        //2、声明一个变量number，给number赋整数值，写出以下表达式，判断number是不是：
        //正数
        //大于100的正数
        //大于100小于1000的正数
        //10000以内能被3整除的奇数
        //static void NumberJudgment(int number)
        //{
        //    if (number > 0)
        //    {
        //        Console.WriteLine("正数");
        //    }//else nothing;
        //    if (number > 100)
        //    {
        //        Console.WriteLine("大于100的正数");
        //    }//else nothing;
        //    if (number > 100 && number < 1000)
        //    {
        //        Console.WriteLine("大于100小于1000的正数");
        //    }//else nothing;
        //    if (number < 10000 && number % 3 == 0)
        //    {
        //        Console.WriteLine("10000以内能被3整除的奇数");
        //    }//else nothing;
        //}


        //3、声明变量sname（学生姓名），将你的名字（比如：阿泰）赋值给它；然后利用它输出入栈口号，比如：我是阿泰，学业不成，誓不出栈！
        //static void SnameStudy(string sname)
        //{
        //    Console.WriteLine("我是" + sname + ",学业不成，誓不出栈！");
        //}


        //1、声明一个函数：函数名为add，接受两个参数a和b，调用该函数，能返回两个参数的和。
        //static int Add(int a, int b)        
        //{
        //    int sum = a + b;           
        //    return sum;
        //}


        //3、将之前“找出素数”的代码封装成一个函数findPrime(max)，可以控制台输出max以内的所有素数。
        //static double[] FindPrime(double max)
        //{
        //    double[] ids = new double[1250]; //创建一个数组存储质数              
        //    int num = 0; //当前存储位置

        //    for (int i = 2; i <= max; i++)
        //    {
        //        bool isPrime = true;

        //        //检查i是否质数
        //        for (int j = 2; j < i; j++)
        //        {
        //            if (i % j == 0)
        //            { ////如果发现整除，立即跳出循环
        //                isPrime = false;
        //                break;
        //            }//else nothing   
        //        }
        //        if (isPrime)
        //        {
        //            ids[num] = i; // 通过索引赋值到数组
        //            num++;         // 移动到下一个位置
        //        }
        //    }
        //    return ids;
        //}


        //4、声明以下函数，接受一个数组作为参数：
        //getSum：返回数组中所有元素的和
        //static double GetSum(double[] ids)
        //{
        //    double idsSum = 0;
        //    for (int i = 0; i < ids.Length; i++)
        //    {
        //        idsSum += ids[i];
        //    }
        //    return idsSum;
        //}

        ////getAverage：返回数组中所有元素的平均值
        //static double GetAverage(double[] ids)
        //{
        //    //double idsSum = 0;
        //    double idsAverage = 0;
        //    //for (int i = 0; i < ids.Length; i++)
        //    //{
        //    //    idsSum += ids[i];
        //    //}
        //    idsAverage = GetSum(ids) / ids.Length;
        //    return idsAverage;
        //}

        ////getMax：返回数组中最大的元素
        //static double GetMax(double[] ids) 
        //{
        //    double max = ids[0];
        //    for (int i = 0; i < ids.Length; i++)
        //    {
        //        if (max < ids[i])
        //        {
        //            max = ids[i];
        //        } //else nothing;
        //    }
        //    return max;
        //}


        ////getMin：返回数组中最小的元素
        //static double GetMin(double[] ids)
        //{
        //    double min = ids[0];
        //    for (int i = 0; i < ids.Length; i++)
        //    {
        //        if (min > ids[i])
        //        {
        //            min = ids[i];
        //        } //else nothing
        //    }
        //    return min;
        //}

        ////getRange：数组中最大一个元素和最小元素的差
        //static double GetRange(double[] ids)
        //{
        //    double max = ids[0];
        //    double min = ids[1];
        //    //找最大值
        //    for (int i = 0; i < ids.Length; i++)
        //    {
        //        if (max < ids[i])
        //        {
        //            max = ids[i];
        //        }//else nothing
        //    }

        //    //找最小值
        //    for (int j = 0; j < ids.Length; j++)
        //    {
        //        if (min > ids[j])
        //        {
        //            min = ids[j];
        //        }//else nothing
        //    }
        //            return max - min;
        //}

        //5、设计一个函数sum，能（用遍历而不是公式）求出任意等差数列（如：1,3,5……或者0,5,10,15……）之和。
        //static double Sum(double start, double step, double number)
        //{
        //    double[] ids = new double[50];
        //     ids[0] = start; 	//起始位置        
        //    double sum = 0;
        //    for (int i = 0; i < number; i++)
        //    {
        //        sum += start + i * step;
        //    }
        //    return sum;
        //}


        //6、设计一个函数swap，能够交换数组中的任意两个元素（提示：引入中间变量）
        //static double[] Swap(double[] ids, double a, double b)
        //{
        //    double variable = a;//中间变量

        //    //第一个数
        //    for (int i = 0; i < ids.Length; i++)
        //    {
        //        if (ids[i] == a)
        //        {
        //            ids[i] = b;
        //        }
        //        else if (ids[i] == b)
        //        {
        //            ids[i] = variable;
        //        }//else nothing
        //    }
        //    return ids;
        //}

        //数据结构
        //冒泡法改造
        //2、将其封装成方法bubbleSort()，且该方法既能按元素本身大小比较，也能按元素的绝对值（即：数组中可能有负数）进行比较


        //public static void BubbleSort(Double[] array, bool useAbs = false)
        //{
        //    for (int i = 0; i < array.Length; i++)
        //    {
        //        for (int j = 0; j < array.Length - i - 1; j++)
        //        {
        //            double current = array[j];
        //            double next = array[j + 1];

        //            // 计算比较值（绝对值或原值）
        //            double currentVal = current;
        //            double nextVal = next;

        //            if (useAbs)
        //            {
        //                currentVal = Abs(current);
        //                nextVal = Abs(next);
        //            }//else nothing
        //            if (currentVal < nextVal)
        //            {
        //                array[j] = next;
        //                array[j + 1] = current;
        //            }//else nothing
        //        }
        //    }
        //}
        //{
        //    //double[] array = [9, 2, 3, 5, -4, 7, -6, 8, 1, 0];

        //    for (int i = 0; i < array.Length - 1; i++)
        //    {
        //        if (Abs(array[i]) < Abs(array[i + 1]))
        //        {
        //            for (int j = i + 1; j > 0; j--)
        //            {

        //                if (Abs(array[j]) > Abs(array[j - 1]))
        //                {
        //                    double temp = array[j];
        //                    array[j] = array[j - 1];
        //                    array[j - 1] = temp;
        //                }
        //                else
        //                {
        //                    break;
        //                }
        //            }
        //        }
        //    }
        //public static void BubbleSort(Double[] array)
        //{
        //    //double[] array = [9, 2, 3, 5, -4, 7, -6, 8, 1, 0];

        //    for (int i = 0; i < array.Length - 1; i++)
        //    {
        //        if (Abs(array[i]) < Abs(array[i + 1]))
        //        {
        //            for (int j = i + 1; j > 0; j--)
        //            {

        //                if (Abs(array[j]) > Abs(array[j - 1]))
        //                {
        //                    double temp = array[j];
        //                    array[j] = array[j - 1];
        //                    array[j - 1] = temp;
        //                }
        //                else
        //                {
        //                    break;
        //                }
        //            }
        //        }
        //    }
        //    for (int i = 0; i < array.Length; i++)
        //    {
        //        Console.Write(array[i] + " ");
        //    }
        //}

        //将参数值转化为绝对值
        //public static double Abs(double value)
        //{
        //    return value < 0 ? -value : value;
        //}

        //3、可以指定数组中的某一个值为最大（就像斗地主有“癞子”一样）

        //public static  void  MaxSort(double[] array,double maxValue)
        //{


        //    //double[] array = [9, 2, 3, 5, -4, 7, -6, 8, 1, 0];  
        //    //将指定最大值放在数组的第一个位置
        //    for (int i = 0; i < array.Length; i++)
        //    {
        //        if (array[i] == maxValue)
        //        {
        //            double temp = array[0];
        //            array[0] = array[i];
        //            array[i] = temp;
        //            break;
        //        }                                                                                                       
        //    }
        //    //从大到小冒泡排序
        //    for (int i = 1; i < array.Length - 1; i++)
        //    {
        //        for (int j = 1; j < array.Length - i - 1; j++)
        //        {
        //            if (array[j] < array[j + 1])
        //            {
        //                double temp = array[j];
        //                array[j] = array[j + 1];
        //                array[j + 1] = temp;
        //            }
        //        }
        //    }
        //}

        //2、完成二分查找法，将其封装成函数/方法：BinarySeek()
        //public static int BinarySeek(int[] array, int target)
        //{
        //    //int[] array = [3, 7, 8, 12, 23, 35, 46, 59, 70, 108];
        //    int left = 0;
        //    int right = array.Length;


        //    while (left < right)
        //    {
        //        int i = (left + right) / 2;
        //        if (target > array[i])
        //        {
        //            left = i + 1;
        //        }
        //        else if (target < array[i])
        //        {
        //            right = i;
        //        }
        //        else
        //        {
        //            return i;
        //        }
        //    }
        //    //找不到
        //    return -1;
        //}

        //3、彻底完成快速排序
        //public static void quickSort(int[] array, int left, int right)
        //{
        //    //递归出口
        //    if (left >= right)
        //    {
        //        return;
        //    }
        //    // 保存初始 left 和 right
        //    int oldLeft = left;
        //    int oldRight = right;

        //    int pivot = array[left];//基准值
        //    int pivotIndex = left;//基准值初始index

        //    //左右指针变动+交换值
        //    while (left < right)
        //    {
        //        // 右指针左移：寻找第一个小于基准值的元素
        //        if (array[right] >= pivot)
        //        {
        //            right--;
        //            continue;  // 保留continue
        //        }

        //        // 左指针右移：寻找第一个大于基准值的元素
        //        if (array[left] <= pivot)
        //        {
        //            left++;
        //            continue;  // 保留continue
        //        }

        //        Swap(array, left, right);
        //    }

        //    //交换基数和终点值
        //    Swap(array, pivotIndex, right);
        //    //更新基准值位置
        //    pivotIndex = right;


        //    //递归调用
        //    quickSort(array, oldLeft, pivotIndex - 1);
        //    quickSort(array, pivotIndex + 1, oldRight);
        //}

        /// <summary>
        /// 交换数组中两个位置的元素
        /// </summary>
        //private static void Swap(int[] array, int i, int j)
        //{
        //    int temp = array[i];
        //    array[i] = array[j];
        //    array[j] = temp;
        //}



    }
}
